تکنیک‌های Currying در جاوا اسکریپت: برنامه‌نویسی تابعی در مقابل Partial Application

در دنیای توسعه جاوا اسکریپت، تسلط بر تکنیک‌های پیشرفته‌ای مانند currying می‌تواند خوانایی، قابلیت استفاده مجدد و نگهداری کلی کد شما را به طور قابل توجهی بهبود بخشد. Currying، یک مفهوم قدرتمند برگرفته از برنامه‌نویسی تابعی، به شما امکان می‌دهد تا یک تابع که چندین آرگومان می‌گیرد را به دنباله‌ای از توابع تبدیل کنید که هر کدام یک آرگومان واحد را می‌پذیرند. این پست وبلاگ به پیچیدگی‌های currying می‌پردازد، آن را با partial application مقایسه می‌کند و مثال‌های عملی برای نشان دادن مزایای آن ارائه می‌دهد.

Currying چیست؟

Currying تبدیل یک تابع است که آن را از حالت قابل فراخوانی به صورت f(a, b, c) به حالت قابل فراخوانی به صورت f(a)(b)(c) ترجمه می‌کند. به زبان ساده‌تر، یک تابع curried تمام آرگومان‌ها را یکجا دریافت نمی‌کند. در عوض، آرگومان اول را می‌گیرد و یک تابع جدید برمی‌گرداند که منتظر آرگومان دوم است، و این روند ادامه می‌یابد تا زمانی که تمام آرگومان‌ها ارائه شوند و نتیجه نهایی بازگردانده شود.

درک مفهوم

یک تابع را تصور کنید که برای انجام عمل ضرب طراحی شده است:

            function multiply(a, b) {
  return a * b;
}
            

              
                Copy
              
            
          

نسخه curried این تابع به این شکل خواهد بود:

            function curriedMultiply(a) {
  return function(b) {
    return a * b;
  }
}
            

              
                Copy
              
            
          

اکنون، می‌توانید آن را به این صورت استفاده کنید:

            const multiplyByTwo = curriedMultiply(2);
console.log(multiplyByTwo(5)); // Output: 10

            

              
                Copy
              
            
          

در اینجا، curriedMultiply(2) یک تابع جدید برمی‌گرداند که مقدار a (که برابر با 2 است) را به خاطر می‌سپارد و منتظر آرگومان دوم b می‌ماند. هنگامی که شما multiplyByTwo(5) را فراخوانی می‌کنید، تابع داخلی با a = 2 و b = 5 اجرا می‌شود و نتیجه 10 خواهد بود.

Currying در مقابل Partial Application

اگرچه اغلب به جای یکدیگر استفاده می‌شوند، currying و partial application مفاهیمی متمایز اما مرتبط هستند. تفاوت اصلی در نحوه اعمال آرگومان‌ها نهفته است:

• Currying: یک تابع با چندین آرگومان را به مجموعه‌ای از توابع تودرتوی یگانی (تک آرگومانی) تبدیل می‌کند. هر تابع دقیقاً یک آرگومان می‌گیرد.
• Partial Application: یک تابع را با پر کردن مقادیر اولیه برخی از آرگومان‌هایش تبدیل می‌کند. این تابع می‌تواند یک یا چند آرگومان را در یک زمان بگیرد، و تابع بازگشتی همچنان باید آرگومان‌های باقیمانده را بپذیرد.

مثال Partial Application

            function greet(greeting, name) {
  return `${greeting}, ${name}!`;
}

function partialGreet(greeting) {
  return function(name) {
    return greet(greeting, name);
  }
}

const sayHello = partialGreet("Hello");
console.log(sayHello("Alice")); // Output: Hello, Alice!

            

              
                Copy
              
            
          

در این مثال، partialGreet آرگومان greeting را می‌گیرد و یک تابع جدید برمی‌گرداند که منتظر name است. این partial application است زیرا لزوماً تابع اصلی را به یک سری توابع یگانی تبدیل نمی‌کند.

مثال Currying

            function curryGreet(greeting) {
  return function(name) {
    return `${greeting}, ${name}!`;
  }
}

const currySayHello = curryGreet("Hello");
console.log(currySayHello("Bob")); // Output: Hello, Bob!

            

              
                Copy
              
            
          

در این مورد، `curryGreet` یک آرگومان می‌گیرد و یک تابع جدید برمی‌گرداند که آرگومان دوم را می‌گیرد. تفاوت اصلی با مثال قبلی ظریف اما مهم است: currying اساساً ساختار تابع را به یک سری توابع تک‌آرگومانی تبدیل می‌کند، در حالی که partial application فقط آرگومان‌ها را از پیش پر می‌کند.

مزایای Currying و Partial Application

هم currying و هم partial application مزایای متعددی در توسعه جاوا اسکریپت ارائه می‌دهند:

• قابلیت استفاده مجدد کد: ایجاد توابع تخصصی از توابع عمومی‌تر با پر کردن آرگومان‌ها.
• خوانایی بهتر: شکستن توابع پیچیده به قطعات کوچکتر و قابل مدیریت‌تر.
• افزایش انعطاف‌پذیری: تطبیق آسان توابع با زمینه‌ها و سناریوهای مختلف.
• اجتناب از تکرار آرگومان: کاهش کدهای تکراری با استفاده مجدد از آرگومان‌های از پیش پر شده.
• ترکیب توابع (Functional Composition): تسهیل ایجاد توابع پیچیده‌تر با ترکیب توابع ساده‌تر.

مثال‌های عملی از Currying و Partial Application

بیایید چند سناریوی عملی را بررسی کنیم که در آنها currying و partial application می‌توانند مفید باشند.

۱. لاگ‌گیری با سطوح از پیش تعریف شده

تصور کنید نیاز به ثبت پیام‌ها با سطوح مختلف شدت (مانند INFO، WARN، ERROR) دارید. می‌توانید از partial application برای ایجاد توابع لاگ‌گیری تخصصی استفاده کنید:

            function log(level, message) {
  console.log(`[${level}] ${message}`);
}

function createLogger(level) {
  return function(message) {
    log(level, message);
  };
}

const logInfo = createLogger("INFO");
const logWarn = createLogger("WARN");
const logError = createLogger("ERROR");

logInfo("Application started successfully.");
logWarn("Low disk space detected.");
logError("Failed to connect to the database.");

            

              
                Copy
              
            
          

این رویکرد به شما امکان می‌دهد تا توابع لاگ‌گیری قابل استفاده مجدد با سطوح شدت از پیش تعریف شده ایجاد کنید و کد خود را تمیزتر و سازمان‌یافته‌تر نمایید.

۲. قالب‌بندی اعداد با تنظیمات منطقه‌ای (Locale)

هنگام کار با اعداد، اغلب نیاز دارید آنها را بر اساس مناطق خاص (locales) قالب‌بندی کنید (مثلاً با استفاده از جداکننده‌های اعشاری یا نمادهای ارزی متفاوت). می‌توانید از currying برای ایجاد توابعی استفاده کنید که اعداد را بر اساس منطقه کاربر قالب‌بندی می‌کنند:

            function formatNumber(locale) {
  return function(number) {
    return number.toLocaleString(locale);
  };
}

const formatGermanNumber = formatNumber("de-DE");
const formatUSNumber = formatNumber("en-US");

console.log(formatGermanNumber(1234.56)); // Output: 1.234,56
console.log(formatUSNumber(1234.56));   // Output: 1,234.56

            

              
                Copy
              
            
          

این مثال نشان می‌دهد که چگونه می‌توان از currying برای ایجاد توابعی استفاده کرد که با تنظیمات فرهنگی مختلف سازگار هستند و برنامه شما را برای مخاطبان جهانی کاربرپسندتر می‌کنند.

۳. ساخت رشته‌های کوئری پویا

ایجاد رشته‌های کوئری پویا یک کار رایج هنگام تعامل با APIها است. Currying می‌تواند به شما کمک کند تا این رشته‌ها را به روشی زیباتر و قابل نگهداری‌تر بسازید:

            function buildQueryString(baseUrl) {
  return function(params) {
    const queryString = Object.entries(params)
      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
      .join('&');
    return `${baseUrl}?${queryString}`;
  };
}

const createApiUrl = buildQueryString("https://api.example.com/data");

const apiUrl = createApiUrl({
  page: 1,
  limit: 20,
  sort: "name"
});

console.log(apiUrl); // Output: https://api.example.com/data?page=1&limit=20&sort=name

            

              
                Copy
              
            
          

این مثال نشان می‌دهد که چگونه می‌توان از currying برای ایجاد تابعی استفاده کرد که URLهای API را با پارامترهای کوئری پویا تولید می‌کند.

۴. مدیریت رویدادها در برنامه‌های وب

Currying می‌تواند هنگام ایجاد event handlerها در برنامه‌های وب فوق‌العاده مفید باشد. با پیکربندی اولیه event handler با داده‌های خاص، می‌توانید میزان کد تکراری را کاهش داده و منطق مدیریت رویداد خود را مختصرتر کنید.

            function handleClick(elementId, message) {
  return function(event) {
    const element = document.getElementById(elementId);
    if (element) {
      element.textContent = message;
    }
  };
}

const button = document.getElementById('myButton');
if (button) {
  button.addEventListener('click', handleClick('myButton', 'Button Clicked!'));
}

            

              
                Copy
              
            
          

در این مثال، `handleClick` به صورت curried پیاده‌سازی شده تا شناسه عنصر و پیام را از ابتدا بپذیرد و تابعی را برگرداند که سپس به عنوان یک event listener متصل می‌شود. این الگو کد را خواناتر و قابل استفاده مجدد می‌کند، به ویژه در برنامه‌های وب پیچیده.

پیاده‌سازی Currying در جاوا اسکریپت

چندین راه برای پیاده‌سازی currying در جاوا اسکریپت وجود دارد. می‌توانید توابع curried را به صورت دستی همانطور که در مثال‌های بالا نشان داده شد ایجاد کنید، یا می‌توانید از توابع کمکی (helper functions) برای خودکارسازی این فرآیند استفاده کنید.

Currying دستی

همانطور که در مثال‌های قبلی نشان داده شد، currying دستی شامل ایجاد توابع تودرتو است که هر کدام یک آرگومان واحد را می‌پذیرند. این رویکرد کنترل دقیقی بر فرآیند currying فراهم می‌کند اما برای توابع با آرگومان‌های زیاد می‌تواند پرحرف باشد.

استفاده از یک تابع کمکی Currying

برای ساده‌سازی فرآیند currying، می‌توانید یک تابع کمکی ایجاد کنید که به طور خودکار یک تابع را به معادل curried آن تبدیل می‌کند. در اینجا نمونه‌ای از یک تابع کمکی currying آورده شده است:

            function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return function(...nextArgs) {
        return curried(...args, ...nextArgs);
      };
    }
  };
}

            

              
                Copy
              
            
          

این تابع curry یک تابع fn را به عنوان ورودی می‌گیرد و یک نسخه curried از آن تابع را برمی‌گرداند. این تابع با جمع‌آوری بازگشتی آرگومان‌ها کار می‌کند تا زمانی که تمام آرگومان‌های مورد نیاز تابع اصلی فراهم شوند. پس از در دسترس بودن تمام آرگومان‌ها، تابع اصلی را با آن آرگومان‌ها اجرا می‌کند.

در اینجا نحوه استفاده از تابع کمکی curry آمده است:

            function add(a, b, c) {
  return a + b + c;
}

const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)(3));     // Output: 6
console.log(curriedAdd(1, 2)(3));   // Output: 6
console.log(curriedAdd(1)(2, 3));   // Output: 6
console.log(curriedAdd(1, 2, 3));   // Output: 6

            

              
                Copy
              
            
          

استفاده از کتابخانه‌هایی مانند Lodash

کتابخانه‌هایی مانند Lodash توابع داخلی برای currying ارائه می‌دهند که اعمال این تکنیک را در پروژه‌های شما حتی آسان‌تر می‌کند. تابع _.curry در Lodash مشابه تابع کمکی توصیف شده در بالا عمل می‌کند، اما گزینه‌ها و ویژگی‌های اضافی نیز ارائه می‌دهد.

            const _ = require('lodash');

function multiply(a, b, c) {
  return a * b * c;
}

const curriedMultiply = _.curry(multiply);

console.log(curriedMultiply(2)(3)(4));   // Output: 24
console.log(curriedMultiply(2, 3)(4)); // Output: 24

            

              
                Copy
              
            
          

تکنیک‌های پیشرفته Currying

فراتر از پیاده‌سازی اولیه currying، چندین تکنیک پیشرفته وجود دارد که می‌تواند انعطاف‌پذیری و گویایی کد شما را بیشتر بهبود بخشد.

آرگومان‌های جایگزین (Placeholder)

آرگومان‌های جایگزین به شما امکان می‌دهند ترتیب اعمال آرگومان‌ها به یک تابع curried را مشخص کنید. این می‌تواند زمانی مفید باشد که می‌خواهید برخی آرگومان‌ها را از پیش پر کنید اما بقیه را برای بعد بگذارید.

            const _ = require('lodash');

function divide(a, b) {
  return a / b;
}

const curriedDivide = _.curry(divide);

const divideBy = curriedDivide(_.placeholder, 2); // Placeholder for the first argument

console.log(divideBy(10)); // Output: 5

            

              
                Copy
              
            
          

در این مثال، از _.placeholder برای نشان دادن این که آرگومان اول باید بعداً پر شود، استفاده می‌شود. این به شما امکان می‌دهد تا تابع divideBy را ایجاد کنید که یک عدد را بر 2 تقسیم می‌کند، صرف نظر از ترتیبی که آرگومان‌ها ارائه می‌شوند.

Auto-Currying

Auto-currying تکنیکی است که در آن یک تابع به طور خودکار بر اساس تعداد آرگومان‌های ارائه شده، خود را curry می‌کند. اگر تابع تمام آرگومان‌های مورد نیاز را دریافت کند، فوراً اجرا می‌شود. در غیر این صورت، یک تابع جدید برمی‌گرداند که منتظر آرگومان‌های باقیمانده است.

            function autoCurry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return (...args2) => curried(...args, ...args2);
    }
  };
}

function greet(greeting, name) {
  return `${greeting}, ${name}!`;
}

const autoCurriedGreet = autoCurry(greet);

console.log(autoCurriedGreet("Hello", "World")); // Output: Hello, World!
console.log(autoCurriedGreet("Hello")("World")); // Output: Hello, World!

            

              
                Copy
              
            
          

این تابع autoCurry به طور خودکار فرآیند currying را مدیریت می‌کند و به شما اجازه می‌دهد تابع را با تمام آرگومان‌ها به یکباره یا در یک سری از فراخوانی‌ها صدا بزنید.

اشتباهات رایج و بهترین شیوه‌ها

در حالی که currying می‌تواند یک تکنیک قدرتمند باشد، مهم است که از مشکلات بالقوه آگاه باشید و از بهترین شیوه‌ها پیروی کنید تا اطمینان حاصل شود که کد شما خوانا و قابل نگهداری باقی می‌ماند.

• استفاده بیش از حد از Currying: از currying بی‌مورد توابع خودداری کنید. فقط زمانی از currying استفاده کنید که مزیت واضحی از نظر قابلیت استفاده مجدد یا خوانایی داشته باشد.
• پیچیدگی: Currying می‌تواند به کد شما پیچیدگی اضافه کند، به خصوص اگر با دقت استفاده نشود. اطمینان حاصل کنید که مزایای currying بر پیچیدگی افزوده شده غلبه دارد.
• دیباگ کردن: دیباگ کردن توابع curried می‌تواند چالش‌برانگیز باشد، زیرا جریان اجرا ممکن است کمتر مستقیم باشد. از ابزارها و تکنیک‌های دیباگ برای درک نحوه اعمال آرگومان‌ها و نحوه اجرای تابع استفاده کنید.
• قراردادهای نام‌گذاری: از نام‌های واضح و توصیفی برای توابع curried و نتایج میانی آنها استفاده کنید. این به سایر توسعه‌دهندگان (و خود آینده‌تان) کمک می‌کند تا هدف هر تابع و نحوه استفاده از آن را درک کنند.
• مستندسازی: توابع curried خود را به طور کامل مستند کنید و هدف هر آرگومان و رفتار مورد انتظار تابع را توضیح دهید.

نتیجه‌گیری

Currying و partial application تکنیک‌های ارزشمندی در جاوا اسکریپت هستند که می‌توانند خوانایی، قابلیت استفاده مجدد و انعطاف‌پذیری کد شما را افزایش دهند. با درک تفاوت‌های بین این مفاهیم و به کارگیری مناسب آنها، می‌توانید کدی تمیزتر و قابل نگهداری‌تر بنویسید که تست و دیباگ آن آسان‌تر است. چه در حال ساخت برنامه‌های وب پیچیده باشید و چه توابع کاربردی ساده، تسلط بر currying و partial application بدون شک مهارت‌های جاوا اسکریپت شما را ارتقا داده و شما را به یک توسعه‌دهنده موثرتر تبدیل می‌کند. به یاد داشته باشید که زمینه پروژه خود را در نظر بگیرید، مزایا را در برابر معایب احتمالی بسنجید و از بهترین شیوه‌ها پیروی کنید تا اطمینان حاصل کنید که currying کیفیت کد شما را بهبود می‌بخشد نه اینکه مانع آن شود.

با پذیرش اصول برنامه‌نویسی تابعی و بهره‌گیری از تکنیک‌هایی مانند currying، می‌توانید به سطوح جدیدی از گویایی و زیبایی در کد جاوا اسکریپت خود دست یابید. همانطور که به کاوش در دنیای توسعه جاوا اسکریپت ادامه می‌دهید، آزمایش currying و partial application را در پروژه‌های خود در نظر بگیرید و کشف کنید که چگونه این تکنیک‌ها می‌توانند به شما در نوشتن کدی بهتر و قابل نگهداری‌تر کمک کنند.